home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / encodings / punycode.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-11-11  |  8KB  |  256 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. ''' Codec for the Punicode encoding, as specified in RFC 3492
  5.  
  6. Written by Martin v. L\xf6wis.
  7. '''
  8. import codecs
  9.  
  10. def segregate(str):
  11.     '''3.1 Basic code point segregation'''
  12.     base = []
  13.     extended = { }
  14.     for c in str:
  15.         if ord(c) < 128:
  16.             base.append(c)
  17.             continue
  18.         extended[c] = 1
  19.     
  20.     extended = extended.keys()
  21.     extended.sort()
  22.     return (''.join(base).encode('ascii'), extended)
  23.  
  24.  
  25. def selective_len(str, max):
  26.     '''Return the length of str, considering only characters below max.'''
  27.     res = 0
  28.     for c in str:
  29.         if ord(c) < max:
  30.             res += 1
  31.             continue
  32.     
  33.     return res
  34.  
  35.  
  36. def selective_find(str, char, index, pos):
  37.     '''Return a pair (index, pos), indicating the next occurrence of
  38.     char in str. index is the position of the character considering
  39.     only ordinals up to and including char, and pos is the position in
  40.     the full string. index/pos is the starting position in the full
  41.     string.'''
  42.     l = len(str)
  43.     while None:
  44.         pos += 1
  45.         if pos == l:
  46.             return (-1, -1)
  47.         c = str[pos]
  48.         continue
  49.         return None
  50.  
  51.  
  52. def insertion_unsort(str, extended):
  53.     '''3.2 Insertion unsort coding'''
  54.     oldchar = 128
  55.     result = []
  56.     oldindex = -1
  57.     for c in extended:
  58.         index = pos = -1
  59.         char = ord(c)
  60.         curlen = selective_len(str, char)
  61.         delta = (curlen + 1) * (char - oldchar)
  62.         while None:
  63.             (index, pos) = selective_find(str, c, index, pos)
  64.             if index == -1:
  65.                 break
  66.             
  67.             delta += index - oldindex
  68.             oldindex = index
  69.             delta = 0
  70.             continue
  71.             oldchar = char
  72.     return result
  73.  
  74.  
  75. def T(j, bias):
  76.     res = 36 * (j + 1) - bias
  77.     if res < 1:
  78.         return 1
  79.     if res > 26:
  80.         return 26
  81.     return res
  82.  
  83. digits = 'abcdefghijklmnopqrstuvwxyz0123456789'
  84.  
  85. def generate_generalized_integer(N, bias):
  86.     '''3.3 Generalized variable-length integers'''
  87.     result = []
  88.     j = 0
  89.     while None:
  90.         t = T(j, bias)
  91.         if N < t:
  92.             result.append(digits[N])
  93.             return result
  94.         N = (N - t) // (36 - t)
  95.         j += 1
  96.         continue
  97.         return None
  98.  
  99.  
  100. def adapt(delta, first, numchars):
  101.     if first:
  102.         delta //= 700
  103.     else:
  104.         delta //= 2
  105.     delta += delta // numchars
  106.     divisions = 0
  107.     while delta > 455:
  108.         delta = delta // 35
  109.         divisions += 36
  110.     bias = divisions + 36 * delta // (delta + 38)
  111.     return bias
  112.  
  113.  
  114. def generate_integers(baselen, deltas):
  115.     '''3.4 Bias adaptation'''
  116.     result = []
  117.     bias = 72
  118.     for points, delta in enumerate(deltas):
  119.         s = generate_generalized_integer(delta, bias)
  120.         result.extend(s)
  121.         bias = adapt(delta, points == 0, baselen + points + 1)
  122.     
  123.     return ''.join(result)
  124.  
  125.  
  126. def punycode_encode(text):
  127.     (base, extended) = segregate(text)
  128.     base = base.encode('ascii')
  129.     deltas = insertion_unsort(text, extended)
  130.     extended = generate_integers(len(base), deltas)
  131.     if base:
  132.         return base + '-' + extended
  133.     return extended
  134.  
  135.  
  136. def decode_generalized_number(extended, extpos, bias, errors):
  137.     '''3.3 Generalized variable-length integers'''
  138.     result = 0
  139.     w = 1
  140.     j = 0
  141.     while None:
  142.         
  143.         try:
  144.             char = ord(extended[extpos])
  145.         except IndexError:
  146.             if errors == 'strict':
  147.                 raise UnicodeError, 'incomplete punicode string'
  148.             errors == 'strict'
  149.             return (extpos + 1, None)
  150.  
  151.         extpos += 1
  152.         if char <= char:
  153.             pass
  154.         elif char <= 90:
  155.             digit = char - 65
  156.         elif char <= char:
  157.             pass
  158.         elif char <= 57:
  159.             digit = char - 22
  160.         elif errors == 'strict':
  161.             raise UnicodeError("Invalid extended code point '%s'" % extended[extpos])
  162.         else:
  163.             return (extpos, None)
  164.         t = 65(j, bias)
  165.         result += digit * w
  166.         if digit < t:
  167.             return (extpos, result)
  168.         w = w * (36 - t)
  169.         j += 1
  170.         continue
  171.         return None
  172.  
  173.  
  174. def insertion_sort(base, extended, errors):
  175.     '''3.2 Insertion unsort coding'''
  176.     char = 128
  177.     pos = -1
  178.     bias = 72
  179.     extpos = 0
  180.     while extpos < len(extended):
  181.         (newpos, delta) = decode_generalized_number(extended, extpos, bias, errors)
  182.         if delta is None:
  183.             return base
  184.         pos += delta + 1
  185.         char += pos // (len(base) + 1)
  186.         if char > 1114111:
  187.             if errors == 'strict':
  188.                 raise UnicodeError, 'Invalid character U+%x' % char
  189.             errors == 'strict'
  190.             char = ord('?')
  191.         
  192.         pos = pos % (len(base) + 1)
  193.         base = base[:pos] + unichr(char) + base[pos:]
  194.         bias = adapt(delta, extpos == 0, len(base))
  195.         extpos = newpos
  196.     return base
  197.  
  198.  
  199. def punycode_decode(text, errors):
  200.     pos = text.rfind('-')
  201.     if pos == -1:
  202.         base = ''
  203.         extended = text
  204.     else:
  205.         base = text[:pos]
  206.         extended = text[pos + 1:]
  207.     base = unicode(base, 'ascii', errors)
  208.     extended = extended.upper()
  209.     return insertion_sort(base, extended, errors)
  210.  
  211.  
  212. class Codec(codecs.Codec):
  213.     
  214.     def encode(self, input, errors = 'strict'):
  215.         res = punycode_encode(input)
  216.         return (res, len(input))
  217.  
  218.     
  219.     def decode(self, input, errors = 'strict'):
  220.         if errors not in ('strict', 'replace', 'ignore'):
  221.             raise UnicodeError, 'Unsupported error handling ' + errors
  222.         errors not in ('strict', 'replace', 'ignore')
  223.         res = punycode_decode(input, errors)
  224.         return (res, len(input))
  225.  
  226.  
  227.  
  228. class IncrementalEncoder(codecs.IncrementalEncoder):
  229.     
  230.     def encode(self, input, final = False):
  231.         return punycode_encode(input)
  232.  
  233.  
  234.  
  235. class IncrementalDecoder(codecs.IncrementalDecoder):
  236.     
  237.     def decode(self, input, final = False):
  238.         if self.errors not in ('strict', 'replace', 'ignore'):
  239.             raise UnicodeError, 'Unsupported error handling ' + self.errors
  240.         self.errors not in ('strict', 'replace', 'ignore')
  241.         return punycode_decode(input, self.errors)
  242.  
  243.  
  244.  
  245. class StreamWriter(Codec, codecs.StreamWriter):
  246.     pass
  247.  
  248.  
  249. class StreamReader(Codec, codecs.StreamReader):
  250.     pass
  251.  
  252.  
  253. def getregentry():
  254.     return codecs.CodecInfo(name = 'punycode', encode = Codec().encode, decode = Codec().decode, incrementalencoder = IncrementalEncoder, incrementaldecoder = IncrementalDecoder, streamwriter = StreamWriter, streamreader = StreamReader)
  255.  
  256.